function [ p, nc ] = LAESAnew( P, B, D, element)
    %inicjalizacja zmiennych
    %najblizsza znaleziona odleglosc
    d=inf; 
    %indeks najblizszego znalezionego
    p=[];
    %pobranie rozmiaru
    nP=size(P,1);
    nB=size(B,2);
    %ograniczenia dolne odleglosci
    G=zeros(nP,1);
    %liczba dokonanych obliczen odleglosci
    nc=0; 
    %uzywane do indeksowania P(Pind)-aktualne P
    Pindex=1:nP;
    %tablica przechowujaca informacje o tym czy pod danym indeksem znajduje
    %sie element z B, a jesli tak to z ktorej kolumny D nalezy korzystac
    %przy aktualizoawniu G
    indexToD=zeros(nP,1);
    indexToD(B)=1:nB;
    
    
    %wybor pierwszego elementu
    %sprawdzamy czy B jest puste, jesli tak to wybieramy pierwszy element z
    %P, czyli algorytm sprowadzi sie do 1NN
    
    if isempty(B) 
        if ~isempty(Pindex)
            s=Pindex(1);
        end
    else
        s=B(1);
    end
   
    %tak dlugo jak w Pind znajduja sie indeksy <=> aktualnie rozpatrywane
    %P nie jest puste
    while ~isempty(Pindex)
        %obliczamy odleglosc 
        dxs=EuclideanDistance(P(s,:),element);       
        %zwiekszamy licznik o 1
        nc=nc+1;
        %jesli znalezlismy blizszy punkt to zapamietujemy go
        if dxs<d 
            p=s;
            d=dxs;
        end
        %wyrzuc s z ropatrywanego P
        Pindex(Pindex==s)=[]; 
                
        if indexToD(s) %jesli nalezy do B
            %zaktualizuj G
            G(Pindex)=max(G(Pindex), abs( D(Pindex,indexToD(s)) - dxs ));
        end
        
        %default condition function
        condition=logical(1);
        
        %wyeliminowac trzeba wszystkie elementy o minimalnej mozliwej
        %odleglosci wiekszej lub rownej najlepszej sposrod P-B, oraz gdy
        %spelniono wrunek sposrod B
        isInB=logical(indexToD(Pindex));
        toEliminate=(G(Pindex)>=d)&(~isInB|condition);
        Pindex(toEliminate)=[];
        isInB=logical(indexToD(Pindex));
        
        %znajdz minimum z aktualnie dostepnej czesci startowego B       
        [garbage, b]=min(G(Pindex(isInB)));
        %okresl oryginalny indeks
        if ~isempty(b)
            actualB=Pindex(isInB);
            b=actualB(b(1));
        end
        
        %znajdz minimum z aktualnie dostepnej P-B
        [garbage, q]=min(G(Pindex(~isInB)));
        %okresl oryginalny indeks
        if ~isempty(q)
            actualP_B=Pindex(~isInB);
            q=actualP_B(q(1));
        end
        %simple choise function
        if isempty(b)
            s=q;
        else
            s=b;
        end
        
    end
end



